package com.such.kit.validate;

import java.math.BigDecimal;
import com.such.kit.MathCalculate;

/**
 * @author SUCH
 * <pre>
 * 数字校验工具类
 * </pre>
 */
public class ValidateNumber {

	/**
	 * <pre>
	 * 比较 value1 是否等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @return true 为相等
	 */
	public static boolean eq(BigDecimal value1, BigDecimal value2) {
		return value1.compareTo(value2) == 0;
	}

	/**
	 * <pre>
	 * 比较 value1 是否等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @return true 为相等
	 */
	public static boolean eq(double value1, double value2) {
		return eq(new BigDecimal(value1), new BigDecimal(value2));
	}

	/**
	 * <pre>
	 * 比较 value1 是否等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @return true 为相等
	 */
	public static boolean eq(String value1, String value2) {
		return eq(new BigDecimal(value1), new BigDecimal(value2));
	}

	/**
	 * <pre>
	 * 比较 value1 是否等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @param tolerance 容差
	 * @return true 为相等
	 */
	public static boolean eq(BigDecimal value1, BigDecimal value2, double tolerance) {
		if (gt(MathCalculate.abs(MathCalculate.subtract(value1, value2)).doubleValue(), tolerance)) {
			return false;
		}
		return true;
	}

	/**
	 * <pre>
	 * 比较 value1 是否等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @param tolerance 容差
	 * @return true 为相等
	 */
	public static boolean eq(double value1, double value2, double tolerance) {
		return eq(new BigDecimal(value1), new BigDecimal(value2), tolerance);
	}

	/**
	 * <pre>
	 * 比较 value1 是否等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @param tolerance 容差
	 * @return true 为相等
	 */
	public static boolean eq(String value1, String value2, double tolerance) {
		return eq(new BigDecimal(value1), new BigDecimal(value2), tolerance);
	}

	/**
	 * <pre>
	 * 比较 value1 是否不等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @return true 为不相等
	 */
	public static boolean ne(BigDecimal value1, BigDecimal value2) {
		return value1.compareTo(value2) != 0;
	}

	/**
	 * <pre>
	 * 比较 value1 是否不等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @return true 为不相等
	 */
	public static boolean ne(double value1, double value2) {
		return ne(new BigDecimal(value1), new BigDecimal(value2));
	}

	/**
	 * <pre>
	 * 比较 value1 是否不等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @return true 为不相等
	 */
	public static boolean ne(String value1, String value2) {
		return ne(new BigDecimal(value1), new BigDecimal(value2));
	}

	/**
	 * <pre>
	 * 比较 value1 是否不等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @param tolerance 容差
	 * @return true 为不相等
	 */
	public static boolean ne(BigDecimal value1, BigDecimal value2, double tolerance) {
		if (gt(MathCalculate.abs(MathCalculate.subtract(value1, value2)).doubleValue(), tolerance)) {
			return true;
		}
		return false;
	}

	/**
	 * <pre>
	 * 比较 value1 是否不等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @param tolerance 容差
	 * @return true 为不相等
	 */
	public static boolean ne(double value1, double value2, double tolerance) {
		return ne(new BigDecimal(value1), new BigDecimal(value2), tolerance);
	}

	/**
	 * <pre>
	 * 比较 value1 是否不等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @param tolerance 容差
	 * @return true 为不相等
	 */
	public static boolean ne(String value1, String value2, double tolerance) {
		return ne(new BigDecimal(value1), new BigDecimal(value2), tolerance);
	}

	/**
	 * <pre>
	 * 比较 value1 是否小于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @return true 为小于
	 */
	public static boolean lt(BigDecimal value1, BigDecimal value2) {
		return value1.compareTo(value2) == -1;
	}

	/**
	 * <pre>
	 * 比较 value1 是否小于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @return true 为小于
	 */
	public static boolean lt(double value1, double value2) {
		return lt(new BigDecimal(value1), new BigDecimal(value2));
	}

	/**
	 * <pre>
	 * 比较 value1 是否小于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @return true 为小于
	 */
	public static boolean lt(String value1, String value2) {
		return lt(new BigDecimal(value1), new BigDecimal(value2));
	}

	/**
	 * <pre>
	 * 比较 value1 是否小于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @param tolerance 容差
	 * @return true 为小于
	 */
	public static boolean lt(BigDecimal value1, BigDecimal value2, double tolerance) {
		return value1.compareTo(MathCalculate.add(value2, new BigDecimal(tolerance))) == -1;
	}

	/**
	 * <pre>
	 * 比较 value1 是否小于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @param tolerance 容差
	 * @return true 为小于
	 */
	public static boolean lt(double value1, double value2, double tolerance) {
		return lt(new BigDecimal(value1), new BigDecimal(value2), tolerance);
	}

	/**
	 * <pre>
	 * 比较 value1 是否小于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @param tolerance 容差
	 * @return true 为小于
	 */
	public static boolean lt(String value1, String value2, double tolerance) {
		return lt(new BigDecimal(value1), new BigDecimal(value2), tolerance);
	}

	/**
	 * <pre>
	 * 比较 value1 是否小于等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @return true 为小于等于
	 */
	public static boolean le(BigDecimal value1, BigDecimal value2) {
		return value1.compareTo(value2) <= 0;
	}

	/**
	 * <pre>
	 * 比较 value1 是否小于等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @return true 为小于等于
	 */
	public static boolean le(double value1, double value2) {
		return le(new BigDecimal(value1), new BigDecimal(value2));
	}

	/**
	 * <pre>
	 * 比较 value1 是否小于等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @return true 为小于等于
	 */
	public static boolean le(String value1, String value2) {
		return le(new BigDecimal(value1), new BigDecimal(value2));
	}

	/**
	 * <pre>
	 * 比较 value1 是否小于等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @param tolerance 容差
	 * @return true 为小于等于
	 */
	public static boolean le(BigDecimal value1, BigDecimal value2, double tolerance) {
		return value1.compareTo(MathCalculate.add(value2, new BigDecimal(tolerance))) <= 0;
	}

	/**
	 * <pre>
	 * 比较 value1 是否小于等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @param tolerance 容差
	 * @return true 为小于等于
	 */
	public static boolean le(double value1, double value2, double tolerance) {
		return le(new BigDecimal(value1), new BigDecimal(value2), tolerance);
	}

	/**
	 * <pre>
	 * 比较 value1 是否小于等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @param tolerance 容差
	 * @return true 为小于等于
	 */
	public static boolean le(String value1, String value2, double tolerance) {
		return le(new BigDecimal(value1), new BigDecimal(value2), tolerance);
	}

	/**
	 * <pre>
	 * 比较 value1 是否大于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @return true 为大于
	 */
	public static boolean gt(BigDecimal value1, BigDecimal value2) {
		return value1.compareTo(value2) == 1;
	}

	/**
	 * <pre>
	 * 比较 value1 是否大于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @return true 为大于
	 */
	public static boolean gt(double value1, double value2) {
		return gt(new BigDecimal(value1), new BigDecimal(value2));
	}

	/**
	 * <pre>
	 * 比较 value1 是否大于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @return true 为大于
	 */
	public static boolean gt(String value1, String value2) {
		return gt(new BigDecimal(value1), new BigDecimal(value2));
	}

	/**
	 * <pre>
	 * 比较 value1 是否大于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @param tolerance 容差
	 * @return true 为大于
	 */
	public static boolean gt(BigDecimal value1, BigDecimal value2, double tolerance) {
		return value1.compareTo(MathCalculate.subtract(value2, new BigDecimal(tolerance))) == 1;
	}

	/**
	 * <pre>
	 * 比较 value1 是否大于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @param tolerance 容差
	 * @return true 为大于
	 */
	public static boolean gt(double value1, double value2, double tolerance) {
		return gt(new BigDecimal(value1), new BigDecimal(value2), tolerance);
	}

	/**
	 * <pre>
	 * 比较 value1 是否大于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @param tolerance 容差
	 * @return true 为大于
	 */
	public static boolean gt(String value1, String value2, double tolerance) {
		return gt(new BigDecimal(value1), new BigDecimal(value2), tolerance);
	}

	/**
	 * <pre>
	 * 比较 value1 是否大于等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @return true 为大于等于
	 */
	public static boolean ge(BigDecimal value1, BigDecimal value2) {
		return value1.compareTo(value2) >= 0;
	}

	/**
	 * <pre>
	 * 比较 value1 是否大于等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @return true 为大于等于
	 */
	public static boolean ge(double value1, double value2) {
		return ge(new BigDecimal(value1), new BigDecimal(value2));
	}

	/**
	 * <pre>
	 * 比较 value1 是否大于等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @return true 为大于等于
	 */
	public static boolean ge(String value1, String value2) {
		return ge(new BigDecimal(value1), new BigDecimal(value2));
	}

	/**
	 * <pre>
	 * 比较 value1 是否大于等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @param tolerance 容差
	 * @return true 为大于等于
	 */
	public static boolean ge(BigDecimal value1, BigDecimal value2, double tolerance) {
		return value1.compareTo(MathCalculate.subtract(value2, new BigDecimal(tolerance))) >= 0;
	}

	/**
	 * <pre>
	 * 比较 value1 是否大于等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @param tolerance 容差
	 * @return true 为大于等于
	 */
	public static boolean ge(double value1, double value2, double tolerance) {
		return ge(new BigDecimal(value1), new BigDecimal(value2), tolerance);
	}

	/**
	 * <pre>
	 * 比较 value1 是否大于等于 value2
	 * </pre>
	 * @param value1 值1
	 * @param value2 值2
	 * @param tolerance 容差
	 * @return true 为大于等于
	 */
	public static boolean ge(String value1, String value2, double tolerance) {
		return ge(new BigDecimal(value1), new BigDecimal(value2), tolerance);
	}

	/**
	 * <pre>
	 * value 是否在 start 到 end 区间内
	 * </pre>
	 * @param value 值
	 * @param start 区间开始值
	 * @param end 区间结束值
	 * @param close 是否闭区间
	 * @return true 为在区间内
	 */
	public static boolean interval(BigDecimal value, BigDecimal start, BigDecimal end, boolean close) {
		boolean boole = false;
		if (close) {
			boole = (ge(value, start) && le(value, end));
		} else {
			boole = (gt(value, start) && lt(value, end));
		}
		return boole;
	}

	/**
	 * <pre>
	 * value 是否在 start 到 end 区间内
	 * </pre>
	 * @param value 值
	 * @param start 区间开始值
	 * @param end 区间结束值
	 * @param close 是否闭区间
	 * @return true 为在区间内
	 */
	public static boolean interval(double value, double start, double end, boolean close) {
		boolean boole = false;
		if (close) {
			boole = (ge(value, start) && le(value, end));
		} else {
			boole = (gt(value, start) && lt(value, end));
		}
		return boole;
	}

	/**
	 * <pre>
	 * value 是否在 start 到 end 区间内
	 * </pre>
	 * @param value 值
	 * @param start 区间开始值
	 * @param end 区间结束值
	 * @param close 是否闭区间
	 * @return true 为在区间内
	 */
	public static boolean interval(String value, String start, String end, boolean close) {
		boolean boole = false;
		if (close) {
			boole = (ge(value, start) && le(value, end));
		} else {
			boole = (gt(value, start) && lt(value, end));
		}
		return boole;
	}

	/**
	 * <pre>
	 * value 是否在 start 到 end 区间内
	 * </pre>
	 * @param value 值
	 * @param start 区间开始值
	 * @param end 区间结束值
	 * @param close 是否闭区间
	 * @param tolerance 容差
	 * @return true 为在区间内
	 */
	public static boolean interval(BigDecimal value, BigDecimal start, BigDecimal end, boolean close, double tolerance) {
		boolean boole = false;
		if (close) {
			boole = (ge(value, start, tolerance) && le(value, end, tolerance));
		} else {
			boole = (gt(value, start, tolerance) && lt(value, end, tolerance));
		}
		return boole;
	}

	/**
	 * <pre>
	 * value 是否在 start 到 end 区间内
	 * </pre>
	 * @param value 值
	 * @param start 区间开始值
	 * @param end 区间结束值
	 * @param close 是否闭区间
	 * @param tolerance 容差
	 * @return true 为在区间内
	 */
	public static boolean interval(double value, double start, double end, boolean close, double tolerance) {
		boolean boole = false;
		if (close) {
			boole = (ge(value, start, tolerance) && le(value, end, tolerance));
		} else {
			boole = (gt(value, start, tolerance) && lt(value, end, tolerance));
		}
		return boole;
	}

	/**
	 * <pre>
	 * value 是否在 start 到 end 区间内
	 * </pre>
	 * @param value 值
	 * @param start 区间开始值
	 * @param end 区间结束值
	 * @param close 是否闭区间
	 * @param tolerance 容差
	 * @return true 为在区间内
	 */
	public static boolean interval(String value, String start, String end, boolean close, double tolerance) {
		boolean boole = false;
		if (close) {
			boole = (ge(value, start, tolerance) && le(value, end, tolerance));
		} else {
			boole = (gt(value, start, tolerance) && lt(value, end, tolerance));
		}
		return boole;
	}

}
